const fs = require('fs');
const path = require('path');
const { execFile, spawn, execSync, execFileSync } = require('child_process');
const os = require('os');

// 函数：获取Windows短路径
function getShortPathFn(longPath) {
  // 验证longPath是否为字符串
  if (typeof longPath !== 'string') {
    console.error('错误：getShortPathFn 要求 longPath 是字符串');
    return longPath; // 如果不是字符串，直接返回原始值
  }

  try {
    // 首先检查文件/目录是否存在
    if (!fs.existsSync(longPath)) {
      console.error('路径不存在:', longPath);
      return longPath;
    }

    // 使用批处理命令获取短路径，不使用chcp命令
    const cmd = `for %A in ("${longPath}") do @echo %~sA`;
    const shortPath = execSync(cmd, {
      shell: 'cmd.exe',
      encoding: 'utf8'
    }).toString().trim();

    // 如果获取到的短路径不是以盘符开头，说明命令执行有问题
    if (!/^[A-Za-z]:/.test(shortPath)) {
      console.error('获取的短路径格式不正确:', shortPath);
      return longPath;
    }

    return shortPath;
  } catch (error) {
    console.error('获取短路径失败:', error.message);
    return longPath; // 如果获取失败，返回原始路径
  }
}

// 函数：获取Windows短目录路径
function getShortDirPathFn(longPath) {
  return getShortPathFn(longPath); // 复用getShortPathFn函数
}

class PdfToImagesConverter {
  constructor(config) {
    this.config = config;
    try {
      this.ensureOutputDirFn();
    } catch (error) {
      console.error('初始化PdfToImagesConverter失败:', error);
      throw error;
    }
  }

  // 确保输出目录存在
  ensureOutputDirFn() {
    try {
      if (!fs.existsSync(this.config.outputDir)) {
        fs.mkdirSync(this.config.outputDir, { recursive: true });
      }
    } catch (error) {
      console.error('创建输出目录失败:', error);
      throw error;
    }
  }

  // 发送进度更新
  sendProgressFn(progress, message = '', mainWindow = null) {
    try {
      // 确保进度值在0-100之间
      const validProgress = Math.max(0, Math.min(100, progress));

      if (mainWindow && !mainWindow.isDestroyed()) {
        mainWindow.webContents.send('progress-update', {
          type: 'pdf-to-images',
          progress: validProgress,
          message
        });
        console.log(`向主窗口发送进度: ${validProgress}%, ${message}`);
      } else if (process && process.send) {
        process.send({
          type: 'pdf-conversion-progress',
          progress: validProgress,
          message
        });
        console.log(`向进程发送进度: ${validProgress}%, ${message}`);
      } else {
        // 如果无法发送进度，直接记录
        console.log(`PDF转换进度: ${validProgress}%, ${message}`);
      }
    } catch (error) {
      console.error(`发送进度更新失败: ${error.message}`);
      console.error('错误详情:', error.stack);
    }
  }

  // 获取pdftocairo路径
  getPdftocairoPathFn() {
    // 使用本地resources目录中的pdftocairo
    return path.join(__dirname, '../resources/poppler/bin/pdftocairo.exe');
  }

  // 转换单页PDF为图片
  convertPdfPageToImageFn(pdfPath, outputPath, pageNum, resolution = 144) {
    return new Promise((resolve, reject) => {
      const pdftocairoPath = this.getPdftocairoPathFn();
      const tempDir = path.join(os.tmpdir(), `pdf_temp_${Date.now()}`);
      const tempPrefix = path.join(tempDir, `page${pageNum}`);

      // 确保临时目录存在
      try {
        if (!fs.existsSync(tempDir)) {
          fs.mkdirSync(tempDir, { recursive: true });
        }
      } catch (error) {
        console.error(`创建临时目录失败: ${error.message}`);
        reject(error);
        return;
      }

      execFile(pdftocairoPath, [
        '-png',           // 输出为PNG格式
        '-singlefile',    // 单文件输出
        '-f', `${pageNum}`,    // 起始页
        '-l', `${pageNum}`,    // 结束页
        '-r', `${resolution}`, // 分辨率
        pdfPath,          // 输入PDF路径
        tempPrefix        // 临时输出路径前缀
      ], (error, stdout, stderr) => {
        try {
          if (error) {
            console.error(`执行pdftocairo失败 (${pdfPath} 第${pageNum}页): ${error.message}`);
            console.error(`标准错误: ${stderr}`);
            reject(error);
            return;
          }

          // 检查临时文件是否存在
          const tempOutputFile = `${tempPrefix}.png`;
          if (fs.existsSync(tempOutputFile)) {
            // 确保输出目录存在
            try {
              const outputDir = path.dirname(outputPath);
              if (!fs.existsSync(outputDir)) {
                fs.mkdirSync(outputDir, { recursive: true });
              }
            } catch (e) {
              console.error(`创建输出目录失败: ${e.message}`);
              reject(e);
              return;
            }

            // 将临时文件移动到最终位置
            try {
              fs.copyFileSync(tempOutputFile, outputPath);
              resolve();
            } catch (e) {
              console.error(`复制图片文件失败: ${e.message}`);
              reject(e);
            }
          } else {
            const errMsg = `找不到生成的图片文件: ${tempOutputFile}`;
            console.error(errMsg);
            reject(new Error(errMsg));
          }
        } catch (e) {
          console.error(`转换PDF页面失败: ${e.message}`);
          reject(e);
        } finally {
          // 清理临时目录
          try {
            if (fs.existsSync(tempDir)) {
              // 使用fs.rmSync确保同步清理，避免在文件复制完成前清理临时目录
              fs.rmSync(tempDir, { recursive: true, force: true });
              console.log('临时目录已清理');
            }
          } catch (e) {
            console.error(`清理临时目录失败: ${e.message}`);
            console.error('错误详情:', e.stack);
          }
        }
      });
    });
  }

  // 获取PDF页数
  getPdfPageCountFn(pdfPath) {
    return new Promise((resolve, reject) => {
      // 使用本地resources目录中的pdfinfo
      const pdfInfoPath = path.join(__dirname, '../resources/poppler/bin/pdfinfo.exe');

      // 尝试使用pdfinfo获取页数
      execFile(pdfInfoPath, [pdfPath], (error, stdout, stderr) => {
        if (error) {
          // 如果pdfinfo不可用，返回默认值1
          console.warn(`执行pdfinfo获取页数失败 (${pdfPath}): ${error.message}`);
          console.warn(`标准错误: ${stderr}`);
          resolve(1);
          return;
        }

        // 从输出中提取页数
        const pageCountMatch = stdout.match(/Pages:\s*(\d+)/i);
        if (pageCountMatch && pageCountMatch[1]) {
          resolve(parseInt(pageCountMatch[1]));
        } else {
          console.warn(`无法从pdfinfo输出中提取页数 (${pdfPath}): ${stdout}`);
          resolve(1);
        }
      });
    });
  }

  // 格式化索引
  formatIndexFn(index) {
    return String(index).padStart(4, '0');
  }

  // 获取pdfimages路径
  getPdfimagesPathFn() {
    // 使用本地resources目录中的pdfimages
    return path.join(__dirname, '../resources/poppler/bin/pdfimages.exe');
  }

  // 从单个PDF中提取原始图片
  async extractRawImagesFromSinglePdfFn(pdfPath, pdfIndex = 1, totalPdfs = 1, mainWindow = null) {
    const self = this;
    const outputDir = self.config.outputDir;
    const pdfName = path.basename(pdfPath, path.extname(pdfPath));

    console.log('开始从单个PDF提取图片:', pdfPath);
    console.log('输出目录:', outputDir);
    let savedImagesCount = 0;

    // 定位pdfimages.exe
    const pdfimagesPath = this.config.pdfimagesPath || this.getPdfimagesPathFn();
    console.log('使用的pdfimages路径:', pdfimagesPath);

    // 检查必要的文件和目录是否存在
    if (!fs.existsSync(pdfimagesPath)) {
      const errorMsg = 'pdfimages.exe不存在';
      console.error(errorMsg, pdfimagesPath);
      throw new Error(errorMsg);
    }

    if (!fs.existsSync(pdfPath)) {
      const errorMsg = 'PDF文件不存在';
      console.error(errorMsg, pdfPath);
      throw new Error(errorMsg);
    }

    // 确保输出目录存在
    try {
      if (!fs.existsSync(outputDir)) {
        fs.mkdirSync(outputDir, { recursive: true });
        console.log('已创建输出目录:', outputDir);
      }
    } catch (error) {
      console.error(`创建输出目录失败: ${error.message}`);
      throw error;
    }

    // 创建临时英文目录来提取图片
    const tempDir = path.join(os.tmpdir(), `pdf_images_temp_${Date.now()}`);
    if (!fs.existsSync(tempDir)) {
      fs.mkdirSync(tempDir, { recursive: true });
      console.log('已创建临时目录:', tempDir);
    }

    try {
      // 创建PDF文件的临时副本，避免pdfimages处理中文路径
      const tempPdfName = `temp_pdf_${Date.now()}.pdf`;
      const tempPdfPath = path.join(tempDir, tempPdfName);

      console.log('创建PDF临时副本:', tempPdfPath);
      // 使用异步复制创建PDF临时副本
      await new Promise((resolve, reject) => {
        fs.copyFile(pdfPath, tempPdfPath, (err) => {
          if (err) {
            console.error('创建PDF临时副本失败:', err.message);
            reject(err);
          } else {
            console.log('PDF临时副本创建成功');
            // 更新进度：PDF临时副本创建完成
            self.sendProgressFn(10, 'PDF临时副本创建完成', mainWindow);
            resolve();
          }
        });
      });

      // 准备命令参数
      // 使用简单的前缀，因为我们将在临时目录中执行命令
      const tempPrefix = `img_${Date.now()}`;

      console.log('临时目录:', tempDir);
      console.log('临时前缀:', tempPrefix);

      const args = [
        '-all',           // 提取所有类型的图片
        '-p',             // 保留页面信息
        // 相对于临时目录的PDF路径（因为我们将在临时目录中执行命令）
        path.basename(tempPdfPath),
        tempPrefix        // 简单的前缀，不包含路径
      ];

      console.log('执行pdfimages命令:', pdfimagesPath);
      console.log('命令参数:', args);

      // 更新进度：开始提取图片
      self.sendProgressFn(20, '开始提取图片...', mainWindow);

      // 使用spawn异步执行pdfimages命令
      await new Promise((resolve, reject) => {
        const child = spawn(pdfimagesPath, args, {
          cwd: tempDir,
          windowsHide: true,
          encoding: 'utf8'
        });

        // 捕获标准输出
        let stdout = '';
        child.stdout.on('data', (data) => {
          stdout += data;
        });

        // 捕获标准错误
        let stderr = '';
        child.stderr.on('data', (data) => {
          stderr += data;
          console.error('pdfimages错误输出:', data.toString());
        });

        // 命令执行完成
        child.on('close', (code) => {
          console.log('pdfimages命令退出码:', code);
          if (code !== 0) {
            console.error('pdfimages命令执行失败');
            console.error('错误输出:', stderr);
            reject(new Error(`pdfimages命令执行失败: ${stderr}`));
            return;
          }

          console.log('pdfimages命令执行成功');
          console.log('输出:', stdout);
          // 更新进度：图片提取完成
          self.sendProgressFn(60, '图片提取完成，开始处理图片文件', mainWindow);
          resolve();
        });

        // 命令执行出错
        child.on('error', (error) => {
          console.error('执行pdfimages命令出错:', error.message);
          reject(new Error(`执行pdfimages命令出错: ${error.message}`));
        });
      });

      // 验证临时目录是否存在
      console.log('=== 验证临时目录 ===');
      if (!fs.existsSync(tempDir)) {
        console.error('临时目录不存在:', tempDir);
        throw new Error('临时目录不存在');
      }
      console.log('临时目录存在:', tempDir);

      // 获取提取的图片文件（异步）
      console.log('=== 读取临时目录 ===');
      const extractedFiles = await new Promise((resolve, reject) => {
        fs.readdir(tempDir, (err, files) => {
          if (err) {
            console.error('读取临时目录失败:', err.message);
            reject(err);
            return;
          }
          resolve(files);
        });
      });
      console.log('临时目录中的文件数量:', extractedFiles.length);
      console.log('临时目录中的所有文件:', extractedFiles);

      // 筛选图片文件
      console.log('=== 筛选图片文件 ===');
      const imageExtensions = ['.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.tif'];
      const tempImageFiles = extractedFiles.filter(file => {
        const ext = path.extname(file).toLowerCase();
        const isImage = imageExtensions.includes(ext);
        console.log(`文件: ${file}，扩展名: ${ext}，是否为图片: ${isImage}`);
        return isImage;
      });
      console.log('使用的图片文件数量:', tempImageFiles.length);
      console.log('使用的图片文件:', tempImageFiles);

      // 重命名并移动图片文件
      let imagesCount = 0;

      if (tempImageFiles.length > 0) {
        console.log('=== 开始重命名并移动临时图片文件 ===');
        // 按文件名排序
        tempImageFiles.sort();
        console.log('排序后的临时图片文件:', tempImageFiles);

        // 重命名并移动图片文件
        imagesCount = tempImageFiles.length;
        console.log('图片总数:', imagesCount);
        savedImagesCount = 0;

        // 批量处理图片文件，使用Promise.all并行处理
        const copyPromises = tempImageFiles.map(async (tempImageFile, index) => {
          const oldPath = path.join(tempDir, tempImageFile);
          const ext = path.extname(tempImageFile);
          console.log(`处理第${index + 1}个文件: ${oldPath}`);

          // 生成文件名
          let fileName;
          if (self.config.isMultipleFiles) {
            fileName = `${pdfName}_${self.formatIndexFn(index + 1)}${ext}`;
          } else {
            const prefix = self.config.filePrefix || pdfName;
            // 始终使用实际的文件扩展名，因为我们是提取原始图片
            fileName = `${prefix}_${self.formatIndexFn(index + 1)}${ext}`;
          }
          console.log(`生成的新文件名: ${fileName}`);

          const newPath = path.join(outputDir, fileName);
          console.log(`移动路径: ${oldPath} -> ${newPath}`);

          // 更新进度：正在复制图片文件
          const progress = 60 + (index / imagesCount) * 30;
          self.sendProgressFn(progress, `正在处理第 ${index + 1}/${imagesCount} 张图片...`, mainWindow);

          // 使用异步复制文件
          return new Promise((resolve, reject) => {
            fs.copyFile(oldPath, newPath, (err) => {
              if (err) {
                console.error('复制文件失败:', err.message);
                // 不 reject，继续处理其他文件
                resolve(false);
                return;
              }

              console.log('成功复制文件');

              // 验证文件是否复制成功
              fs.stat(newPath, (statErr, stats) => {
                if (statErr) {
                  console.log('文件复制验证失败:', statErr.message);
                  resolve(false);
                  return;
                }

                console.log('文件复制验证成功');
                console.log('文件大小:', stats.size);
                savedImagesCount++;
                resolve(true);
              });
            });
          });
        });

        // 等待所有文件复制完成
        await Promise.all(copyPromises);
      } else {
        console.log('=== 没有找到临时文件，尝试使用所有图片文件 ===');
        const imageExtensions = ['.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.tif'];
        const allImageFiles = extractedFiles.filter(file => {
          const ext = path.extname(file).toLowerCase();
          const isImage = imageExtensions.includes(ext);
          console.log(`文件: ${file}，扩展名: ${ext}，是否为图片: ${isImage}`);
          return isImage;
        });
        console.log('所有图片文件:', allImageFiles);

        // 如果找到图片文件，使用它们
        if (allImageFiles.length > 0) {
          console.log('=== 开始重命名并移动所有图片文件 ===');
          // 按文件名排序
          allImageFiles.sort();

          // 重命名并移动图片文件
          imagesCount = allImageFiles.length;
          console.log('图片总数:', imagesCount);
          savedImagesCount = 0;

          // 使用异步方式处理所有图片文件
          const copyPromises = allImageFiles.map(async (file, index) => {
            const oldPath = path.join(tempDir, file);
            const ext = path.extname(file);
            console.log(`处理第${index + 1}个文件: ${oldPath}`);

            // 生成文件名
            let fileName;
            if (self.config.isMultipleFiles) {
              fileName = `${pdfName}_${self.formatIndexFn(index + 1)}${ext}`;
            } else {
              const prefix = self.config.filePrefix || pdfName;
              fileName = `${prefix}_${self.formatIndexFn(index + 1)}${ext}`;
            }
            console.log(`生成的新文件名: ${fileName}`);

            const newPath = path.join(outputDir, fileName);
            console.log(`移动路径: ${oldPath} -> ${newPath}`);

            // 更新进度：正在复制图片文件
            const progress = 60 + (index / imagesCount) * 30;
            self.sendProgressFn(progress, `正在处理第 ${index + 1}/${imagesCount} 张图片...`, mainWindow);

            // 使用异步复制文件
            return new Promise((resolve, reject) => {
              fs.copyFile(oldPath, newPath, (err) => {
                if (err) {
                  console.error('复制文件失败:', err.message);
                  resolve(false);
                  return;
                }

                console.log('成功复制文件');

                // 验证文件是否复制成功
                fs.stat(newPath, (statErr, stats) => {
                  if (statErr) {
                    console.log('文件复制验证失败:', statErr.message);
                    resolve(false);
                    return;
                  }

                  console.log('文件复制验证成功');
                  console.log('文件大小:', stats.size);
                  savedImagesCount++;
                  resolve(true);
                });
              });
            });
          });

          // 等待所有文件复制完成
          await Promise.all(copyPromises);
        } else {
          console.log('没有找到任何图片文件');
        }
      }

      // 更新进度：图片提取完成
      console.log('=== 更新进度 ===');
      self.sendProgressFn(95, '图片提取完成，正在清理临时文件...', mainWindow);

      // 等待异步操作完成后再清理临时文件
      setTimeout(() => {
        // 清理临时目录
        try {
          fs.rmSync(tempDir, { recursive: true, force: true });
          console.log('已清理临时目录:', tempDir);
        } catch (cleanupError) {
          console.error('清理临时目录失败:', cleanupError.message);
        }
      }, 1000); // 等待1秒确保异步操作完成

      console.log('=== 提取完成 ===');
      return {
        pdfPath,
        pdfName,
        imagesCount,
        savedImagesCount,
        outputDir
      };
    } catch (error) {
      console.error('=== 执行命令时发生错误 ===');
      console.error('命令错误:', error);
      console.error('错误信息:', error.message);

      // 清理临时目录
      if (tempDir && fs.existsSync(tempDir)) {
        try {
          fs.rmSync(tempDir, { recursive: true, force: true });
          console.log('已清理临时目录:', tempDir);
        } catch (cleanupError) {
          console.error('清理临时目录失败:', cleanupError.message);
        }
      }

      throw error;
    }
  }

  // 从多个PDF中提取原始图片
  async extractRawImagesFromMultiplePdfsFn(pdfPaths, mainWindow = null) {
    const results = [];

    for (let i = 0; i < pdfPaths.length; i++) {
      const pdfPath = pdfPaths[i];
      try {
        const pdfResult = await this.extractRawImagesFromSinglePdfFn(pdfPath, i + 1, pdfPaths.length, mainWindow);
        results.push(pdfResult);
      } catch (error) {
        console.error(`处理PDF文件失败 (${pdfPath}):`, error);
        // 继续处理下一个PDF
      }
    }

    return results;
  }

  // 提取PDF中的原始图片
  async extractRawImagesFn(mainWindow = null) {
    let results;

    try {
      console.log('extractRawImagesFn 开始执行');
      console.log('this.config:', JSON.stringify(this.config, null, 2));

      const pdfPaths = this.config.pdfPaths;

      // 更新进度
      this.sendProgressFn(0, '开始提取图片...', mainWindow);

      console.log('pdfPaths:', pdfPaths);
      console.log('pdfPaths type:', typeof pdfPaths);
      console.log('pdfPaths is array:', Array.isArray(pdfPaths));

      if (!pdfPaths) {
        const errMsg = 'pdfPaths 为 null 或 undefined';
        console.error(errMsg);
        this.sendProgressFn(100, `提取失败: ${errMsg}`, mainWindow);
        return {
          success: false,
          message: '提取PDF原始图片失败: ' + errMsg,
          results: []
        };
      }

      // 确保 pdfPaths 是数组
      const normalizedPdfPaths = Array.isArray(pdfPaths) ? pdfPaths : [pdfPaths];

      console.log('normalizedPdfPaths:', normalizedPdfPaths);
      console.log('normalizedPdfPaths length:', normalizedPdfPaths.length);

      if (normalizedPdfPaths.length === 0) {
        const errMsg = '未提供有效的PDF文件路径';
        console.error(errMsg);
        this.sendProgressFn(100, `提取失败: ${errMsg}`, mainWindow);
        return {
          success: false,
          message: '提取PDF原始图片失败: ' + errMsg,
          results: []
        };
      }

      // 根据是单个还是多个PDF文件进行处理
      if (normalizedPdfPaths.length > 1) {
        // 处理多个PDF文件
        this.config.isMultipleFiles = true;
        console.log(`开始从多个PDF文件提取图片，共 ${normalizedPdfPaths.length} 个`);
        results = await this.extractRawImagesFromMultiplePdfsFn(normalizedPdfPaths, mainWindow);
      } else {
        // 处理单个PDF文件
        this.config.isMultipleFiles = false;
        console.log(`开始从单个PDF文件提取图片: ${normalizedPdfPaths[0]}`);
        const result = await this.extractRawImagesFromSinglePdfFn(normalizedPdfPaths[0], 1, 1, mainWindow);
        results = [result];
      }

      // 更新进度为完成
      this.sendProgressFn(100, '图片提取完成', mainWindow);

      console.log('所有PDF文件图片提取完成');

      // 确保results是可序列化的
      const serializableResults = results.map(item => {
        return {
          pdfPath: item.pdfPath,
          pdfName: item.pdfName,
          imagesCount: item.imagesCount,
          savedImagesCount: item.savedImagesCount,
          outputDir: item.outputDir
        };
      });

      console.log('serializableResults:', JSON.stringify(serializableResults, null, 2));

      return {
        success: true,
        message: 'PDF原始图片提取成功',
        results: serializableResults
      };
    } catch (error) {
      console.error('PDF原始图片提取失败:', error);
      console.error('错误详情:', error.stack);
      // 更新进度为失败
      this.sendProgressFn(100, `提取失败: ${error.message}`, mainWindow);
      return {
        success: false,
        message: 'PDF原始图片提取失败: ' + error.message,
        results: []
      };
    }
  }

  // 处理单个PDF文件
  async processSinglePdfFn(pdfPath, pdfIndex = 1, totalPdfs = 1, mainWindow = null) {
    const pdfName = path.basename(pdfPath, '.pdf');
    let pageCount = 1;

    try {
      // 获取PDF页数
      pageCount = await this.getPdfPageCountFn(pdfPath);
    } catch (error) {
      console.error(`获取PDF页数失败 (${pdfPath}):`, error);
    }

    // 转换每一页
    for (let pageNum = 1; pageNum <= pageCount; pageNum++) {
      // 生成文件名
      let fileName;
      if (this.config.isMultipleFiles) {
        // 多个PDF文件时，使用PDF名称+页码
        fileName = `${pdfName}_${this.formatIndexFn(pageNum)}.png`;
      } else {
        // 单个PDF文件时，使用用户指定的前缀+页码
        const prefix = this.config.filePrefix || pdfName;
        fileName = `${prefix}_${this.formatIndexFn(pageNum)}.${this.config.outputFormat}`;
      }

      const outputPath = path.join(this.config.outputDir, fileName);

      // 计算进度
      const progress = ((pdfIndex - 1) / totalPdfs + pageNum / pageCount / totalPdfs) * 100;

      // 更新进度
      this.sendProgressFn(progress, `正在转换第 ${pageNum}/${pageCount} 页...`, mainWindow);

      // 转换当前页
      try {
        await this.convertPdfPageToImageFn(pdfPath, outputPath, pageNum);
      } catch (error) {
        console.error(`转换PDF页面失败 (${pdfPath} 第${pageNum}页):`, error);
        throw error;
      }
    }

    return {
      pdfPath,
      pdfName,
      imagesCount: pageCount,
      savedImagesCount: pageCount,
      outputDir: this.config.outputDir
    };
  }

  // 处理多个PDF文件
  async processMultiplePdfsFn(pdfPaths, mainWindow = null) {
    const results = [];

    for (let i = 0; i < pdfPaths.length; i++) {
      const pdfPath = pdfPaths[i];
      try {
        const pdfResult = await this.processSinglePdfFn(pdfPath, i + 1, pdfPaths.length, mainWindow);
        results.push(pdfResult);
      } catch (error) {
        console.error(`处理PDF文件失败 (${pdfPath}):`, error);
        throw error;
      }
    }

    return results;
  }

  // 执行转换
  async convertFn(mainWindow = null) {
    let results;

    try {
      console.log('convertFn 开始执行');
      console.log('this.config:', JSON.stringify(this.config, null, 2));

      const pdfPaths = this.config.pdfPaths;

      // 更新进度
      this.sendProgressFn(0, '开始转换...', mainWindow);

      console.log('pdfPaths:', pdfPaths);
      console.log('pdfPaths type:', typeof pdfPaths);
      console.log('pdfPaths is array:', Array.isArray(pdfPaths));

      if (!pdfPaths) {
        const errMsg = 'pdfPaths 为 null 或 undefined';
        console.error(errMsg);
        this.sendProgressFn(100, `转换失败: ${errMsg}`, mainWindow);
        return {
          success: false,
          message: 'PDF转图片失败: ' + errMsg,
          results: []
        };
      }

      // 确保 pdfPaths 是数组
      const normalizedPdfPaths = Array.isArray(pdfPaths) ? pdfPaths : [pdfPaths];

      console.log('normalizedPdfPaths:', normalizedPdfPaths);
      console.log('normalizedPdfPaths length:', normalizedPdfPaths.length);

      if (normalizedPdfPaths.length === 0) {
        const errMsg = '未提供有效的PDF文件路径';
        console.error(errMsg);
        this.sendProgressFn(100, `转换失败: ${errMsg}`, mainWindow);
        return {
          success: false,
          message: 'PDF转图片失败: ' + errMsg,
          results: []
        };
      }

      // 根据是单个还是多个PDF文件进行处理
      if (normalizedPdfPaths.length > 1) {
        // 处理多个PDF文件
        this.config.isMultipleFiles = true;
        console.log(`开始处理多个PDF文件，共 ${normalizedPdfPaths.length} 个`);
        results = await this.processMultiplePdfsFn(normalizedPdfPaths, mainWindow);
      } else {
        // 处理单个PDF文件
        this.config.isMultipleFiles = false;
        console.log(`开始处理单个PDF文件: ${normalizedPdfPaths[0]}`);
        const result = await this.processSinglePdfFn(normalizedPdfPaths[0], 1, 1, mainWindow);
        results = [result];
      }

      // 更新进度为完成
      this.sendProgressFn(100, '转换完成', mainWindow);

      console.log('所有PDF文件转换完成');

      // 确保results是可序列化的
      const serializableResults = results.map(item => {
        return {
          pdfPath: item.pdfPath,
          pdfName: item.pdfName,
          imagesCount: item.imagesCount,
          savedImagesCount: item.savedImagesCount,
          outputDir: item.outputDir
        };
      });

      console.log('serializableResults:', JSON.stringify(serializableResults, null, 2));

      return {
        success: true,
        message: 'PDF转图片成功',
        results: serializableResults
      };
    } catch (error) {
      console.error('PDF转图片失败:', error);
      console.error('错误详情:', error.stack);
      // 更新进度为失败
      this.sendProgressFn(100, `转换失败: ${error.message}`, mainWindow);
      return {
        success: false,
        message: 'PDF转图片失败: ' + error.message,
        results: []
      };
    }
  }
}

module.exports = PdfToImagesConverter;
